import { getObjType } from '../utils/util';
import { getSheetIndex } from '../methods/get';
import Store from '../store';

// 动态数组计算
function dynamicArrayCompute (dynamicArray) {
    let dynamicArray_compute = {};

    if (getObjType(dynamicArray) == "array") {
        for (let i = 0; i < dynamicArray.length; i++) {
            let d_row = dynamicArray[i].r;
            let d_col = dynamicArray[i].c;
            let d_f = dynamicArray[i].f;

            if (Store.flowdata[d_row][d_col] != null && Store.flowdata[d_row][d_col].f != null && Store.flowdata[d_row][d_col].f == d_f) {
                if ((d_row + "_" + d_col) in dynamicArray_compute) {
                    dynamicArray_compute = dynamicArraySpillEditCompute(dynamicArray_compute, d_row, d_col);
                }

                let d_data = dynamicArray[i].data;
                let d_rowlen = d_data.length;
                let d_collen = 1;

                if (getObjType(d_data[0]) == "array") {
                    d_collen = d_data[0].length;
                }

                if (dynamicArrayRangeIsAllNull({ "row": [d_row, d_row + d_rowlen - 1], "column": [d_col, d_col + d_collen - 1] }, Store.flowdata)) {
                    for (let x = 0; x < d_rowlen; x++) {
                        for (let y = 0; y < d_collen; y++) {
                            let rowIndex = d_row + x;
                            let colIndex = d_col + y;

                            if (getObjType(d_data[0]) == "array") {
                                dynamicArray_compute[rowIndex + "_" + colIndex] = { "v": d_data[x][y], "r": d_row, "c": d_col };
                            } else {
                                dynamicArray_compute[rowIndex + "_" + colIndex] = { "v": d_data[x], "r": d_row, "c": d_col };
                            }
                        }
                    }
                } else {
                    dynamicArray_compute[d_row + "_" + d_col] = { "v": "#SPILL!", "r": d_row, "c": d_col };
                }
            }
        }
    }

    return dynamicArray_compute;
}

function dynamicArraySpillEditCompute (computeObj, r, c) {
    let rowIndex = computeObj[r + "_" + c].r;
    let colIndex = computeObj[r + "_" + c].c;

    for (let x in computeObj) {
        if (x == (rowIndex + "_" + colIndex)) {
            computeObj[x].v = "#SPILL!";
        } else if (computeObj[x].r == rowIndex && computeObj[x].c == colIndex) {
            delete computeObj[x];
        }
    }

    return computeObj;
}

// 范围是否都是空单元格(除第一个单元格)
function dynamicArrayRangeIsAllNull (range, data) {
    let r1 = range.row[0], r2 = range.row[1];
    let c1 = range.column[0], c2 = range.column[1];

    let isAllNull = true;
    for (let r = r1; r <= r2; r++) {
        for (let c = c1; c <= c2; c++) {
            if (!(r == r1 && c == c1) && data[r][c] != null && data[r][c].v != null && data[r][c].v.toString() != "") {
                isAllNull = false;
                break;
            }
        }
    }

    return isAllNull;
}

// 点击表格区域是否属于动态数组区域
function dynamicArrayHightShow (r, c) {
    let dynamicArray = Store.luckysheetfile[getSheetIndex(Store.currentSheetIndex)].dynamicArray == null ? [] : Store.luckysheetfile[getSheetIndex(Store.currentSheetIndex)].dynamicArray;
    let dynamicArray_compute = dynamicArrayCompute(dynamicArray);

    if ((r + "_" + c) in dynamicArray_compute && dynamicArray_compute[r + "_" + c].v != "#SPILL!") {
        let d_row = dynamicArray_compute[r + "_" + c].r;
        let d_col = dynamicArray_compute[r + "_" + c].c;

        let d_f = Store.flowdata[d_row][d_col].f;

        let rlen, clen;
        for (let i = 0; i < dynamicArray.length; i++) {
            if (dynamicArray[i].f == d_f) {
                rlen = dynamicArray[i].data.length;

                if (getObjType(dynamicArray[i].data[0]) == "array") {
                    clen = dynamicArray[i].data[0].length;
                } else {
                    clen = 1;
                }
            }
        }

        let d_row_end = d_row + rlen - 1;
        let d_col_end = d_col + clen - 1;

        let row = Store.visibledatarow[d_row_end],
            row_pre = d_row - 1 == -1 ? 0 : Store.visibledatarow[d_row - 1];
        let col = Store.visibledatacolumn[d_col_end],
            col_pre = d_col - 1 == -1 ? 0 : Store.visibledatacolumn[d_col - 1];

        $("#luckysheet-dynamicArray-hightShow").css({
            "left": col_pre,
            "width": col - col_pre - 1,
            "top": row_pre,
            "height": row - row_pre - 1,
            "display": "block"
        });
    } else {
        $("#luckysheet-dynamicArray-hightShow").hide();
    }
}

export {
    dynamicArrayCompute,
    dynamicArraySpillEditCompute,
    dynamicArrayRangeIsAllNull,
    dynamicArrayHightShow
};
